home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 076-100 / disk_097 / graphit / three-d.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  7KB  |  304 lines
  1. #include "graph.h"
  2.  
  3. #define ANGLEX    45
  4.  
  5. long int xcenter, ycenter;
  6. long int minx, miny, maxx, maxy;
  7. double xconversion, yconversion;
  8. double SINX, COSX;
  9.  
  10. Plot3dGraph(Window, parameters)
  11. struct Graph_Parameters *parameters;
  12. struct Window *Window;
  13.     {
  14.     extern double x,y,z,t;
  15.     extern long int xcenter, ycenter;
  16.     extern double xconversion, yconversion;
  17.     extern double SINX, COSX;
  18.     extern long int minx, miny, maxx, maxy;
  19.  
  20.     double a, x1, x2, y1, y2, z1, z2, xnext, ynext, xtemp, ytemp;
  21.     double xstep, ystep, minz, maxz;
  22.     double xsize, ysize, top, bottom, left, right;
  23.  
  24. /* the stuff needed for hidden lines                    */
  25.     WORD *areabuffer;
  26.     struct TmpRas tmpras;
  27.     struct TmpRas *lasttmp;
  28.     struct AreaInfo myAreaInfo;
  29.     char *raster;
  30.  
  31.     minx = Window->BorderLeft;
  32.     miny = Window->BorderTop;
  33.     maxx = Window->Width - Window->BorderRight - XBORDER;
  34.     maxy = Window->Height - Window->BorderBottom - YBORDER;
  35.  
  36. /* setup things for whats is needed for hidden        */
  37.     if (parameters->hidden)
  38.         {
  39.         areabuffer = AllocMem(sizeof(WORD) * 750l, MEMF_CHIP);
  40.         if (areabuffer == NULL) parameters->hidden = FALSE;
  41.         else
  42.             {
  43.             InitArea(&myAreaInfo, areabuffer, 300l);
  44.             Window->RPort->AreaInfo = &myAreaInfo;
  45.  
  46.             raster = AllocRaster(maxx, maxy);
  47.             if (raster == NULL) parameters->hidden = FALSE;
  48.             else
  49.                 {
  50.                 lasttmp = Window->RPort->TmpRas;
  51.                 InitTmpRas(&tmpras, raster, RASSIZE(maxx, maxy));
  52.                 Window->RPort->TmpRas = &tmpras;
  53.                 }
  54.             }
  55.         }
  56.  
  57.     a=ANGLEX * PI / 180;    /* I hate to do this but my doubles do not    */
  58.     SINX = sin(a);            /* work right under Manx 3.30                */
  59.     COSX = cos(a);
  60.  
  61.     left = 0;
  62.     right = 0;
  63.  
  64.     if (parameters->xend > 0 ) left = parameters->xend * COSX;
  65.     if (parameters->xstart < 0 ) right = -parameters->xstart * COSX;
  66.  
  67.     if (parameters->ystart < 0) left   -= parameters->ystart;
  68.     if (parameters->yend   > 0) right  += parameters->yend;
  69.  
  70.     xsize = left + right;
  71.     ysize = parameters->yend - parameters->ystart;
  72.  
  73.     xconversion = (maxx - minx) / xsize; 
  74.     yconversion = (maxy - miny) / ysize; 
  75.  
  76.     xstep = parameters->detail / xconversion;
  77.     ystep = parameters->detail / yconversion;
  78.  
  79. /* analyze the graph to determine the max hight and min hight    */
  80.     minz =  INFINITY;
  81.     maxz = -INFINITY;
  82.  
  83.     SetAPen(Window->RPort, 1l);
  84.     SetBPen(Window->RPort, 0l);
  85.     SetDrMd(Window->RPort, JAM2);
  86.     Print(Window, "Please Wait Analyzing Graph", 1);
  87.  
  88.     y = parameters->ystart;
  89.     while ( y < parameters->yend )
  90.         {
  91.         x = parameters->xstart;
  92.         while ( x < parameters->xend )
  93.             {
  94.             parameters->z1->position = 0;
  95.             z1 = Solve(parameters->z1);
  96.             x += xstep; 
  97.             z  = (z1 - x * COSX);
  98.             minz = min(minz, z);
  99.             maxz = max(maxz, z);
  100.             } /* end of  xwhile */
  101.         y += parameters->ylabels;
  102.         }    /* end of y loop */
  103.  
  104.     ysize = maxz - minz;
  105.     yconversion = (maxy - miny) / ysize;
  106.  
  107.     ystep = parameters->detail / yconversion;
  108.  
  109.     if (left > 0 ) xcenter = left * xconversion + minx + 2;
  110.     else xcenter = -left * xconversion + minx + 2;
  111.  
  112.     ycenter = maxy + minz * yconversion;
  113.  
  114. /* Draw the Graph rectangle area    */
  115.  
  116.     SetAPen(Window->RPort, 0);
  117.     SetOPen(Window->RPort, 2);
  118.     SetDrMd(Window->RPort, JAM2);
  119.     DrawRectangle(Window, 1, minx, miny, maxx, maxy);
  120.  
  121.     xconversion *= 0.90;
  122.     yconversion *= 0.90;
  123.  
  124.     Line3d(Window, 2l, 0.0, 0.0, 0.0, parameters->xend, 0.0, 0.0);
  125.     Line3d(Window, 2l, 0.0, 0.0, 0.0, 0.0, parameters->yend, 0.0);
  126.     Line3d(Window, 2l, 0.0, 0.0, 0.0, 0.0, 0.0, parameters->zend);
  127.  
  128.     ynext = parameters->ystart;
  129.     while (ynext < parameters->yend)
  130.         {
  131.         xnext = parameters->xstart;
  132.         while (xnext < parameters->xend)
  133.             {
  134.             parameters->z1->position = 0;
  135.             x = xnext;
  136.             y = ynext;
  137.             x1 = x;
  138.             y1 = y;
  139.             z1 = Solve(parameters->z1);
  140.             InitVertices(Window, parameters, 1l, x1, y1, z1);
  141.  
  142.             while (x < xnext + parameters->xlabels)
  143.                 {
  144.                 parameters->z1->position = 0;
  145.                 x += xstep; 
  146.                 x1 = x;
  147.                 y1 = y;
  148.                 z1 = Solve(parameters->z1);
  149.                 AddVertice(Window, parameters, x1, y1, z1);
  150.                 } /* end of xblock while */
  151.  
  152.             xtemp = x1;
  153.             while (y < ynext + parameters->ylabels)
  154.                 {
  155.                 parameters->z1->position = 0;
  156.                 y += ystep; 
  157.                 x1 = x;
  158.                 y1 = y;
  159.                 z1 = Solve(parameters->z1);
  160.                 AddVertice(Window, parameters, x1, y1, z1);
  161.                 } /* end of yblock while */
  162.  
  163.             ytemp = y1;
  164.             if (parameters->hidden || xnext == parameters->xstart
  165.                 || y >= parameters->yend)
  166.                 {
  167.                 while (x > xnext)
  168.                     {
  169.                     parameters->z1->position = 0;
  170.                     x -= xstep; 
  171.                     x1 = x;
  172.                     y1 = y;
  173.                     z1 = Solve(parameters->z1);
  174.                     AddVertice(Window, parameters, x1, y1, z1);
  175.                     } /* end of xblock while */
  176.                 }    /* end of the check to see if valid */
  177.  
  178.             if (parameters->hidden || xnext == parameters->xstart)
  179.                 {
  180.                 while (y > ynext)
  181.                     {
  182.                     parameters->z1->position = 0;
  183.                     y -= ystep; 
  184.                     x1 = x;
  185.                     y1 = y;
  186.                     z1 = Solve(parameters->z1);
  187.                     AddVertice(Window, parameters,  x1, y1, z1);
  188.                     } /* end of yblock while */
  189.                 }    /* end of the if */
  190.  
  191.             DrawVertices(Window, parameters);
  192.             xnext = xtemp;
  193.             } /* end of  xmaster */
  194.         ynext = ytemp;
  195.         }    /* end of ymaster */
  196.  
  197.     if (parameters->hidden)
  198.         {
  199.         FreeRaster(raster, maxx, maxy);
  200.         FreeMem(areabuffer, sizeof(WORD) * 750l);
  201.         Window->RPort->TmpRas = lasttmp;
  202.         }
  203.     return();
  204.     }
  205.  
  206. Line3d(Window, colour, x1, y1, z1, x2, y2, z2)
  207. struct Window *Window;
  208. long int colour;
  209. double x1, y1, z1, x2, y2, z2;
  210.     {
  211.     extern long int xcenter, ycenter;
  212.     extern double xconversion, yconversion;
  213.     extern double SINX, COSX;
  214.  
  215.     long int xa, ya, xb, yb;
  216.  
  217.     xa = xcenter + (x1 * SINX - y1) * xconversion;
  218.     ya = ycenter - (x1 * COSX - z1) * yconversion;
  219.  
  220.     xb = xcenter + (x2 * SINX - y2) * xconversion;
  221.     yb = ycenter - (x2 * COSX - z2) * yconversion;
  222.  
  223.     Line(Window, colour, xa, ya, xb, yb);
  224.     }
  225.  
  226. long int lastx, lasty;
  227. int points;
  228.  
  229. InitVertices(Window, parameters, colour, x1, y1, z1)
  230. struct Window *Window;
  231. struct Graph_Parameters *parameters;
  232. long int colour;
  233. double x1, y1, z1;
  234.     {
  235.     extern long int xcenter, ycenter;
  236.     extern double xconversion, yconversion;
  237.     extern double SINX, COSX;
  238.     extern long minx, miny, maxx, maxy;
  239.     extern int lastx, lasty;
  240.     extern int points;
  241.  
  242.     long int xa, ya;
  243.  
  244.     xa = xcenter + (x1 * SINX - y1) * xconversion;
  245.     ya = ycenter - (x1 * COSX - z1) * yconversion;
  246.  
  247.     lastx = xa;
  248.     lasty = ya;
  249.  
  250.     if (!(xa > minx && xa < maxx && ya > miny && ya < maxy) ) return();
  251.  
  252.     SetOPen(Window->RPort, colour);
  253.     SetAPen(Window->RPort, 0l);
  254.  
  255.     points = 1;
  256.     if (parameters->hidden) AreaMove(Window->RPort, xa, ya);
  257.     else
  258.         {
  259.         Move(Window->RPort, xa, ya);
  260.         SetAPen(Window->RPort, colour);
  261.         }
  262.     }
  263.  
  264. AddVertice(Window, parameters, x1, y1, z1)
  265. struct Window *Window;
  266. struct Graph_Parameters *parameters;
  267. double x1, y1, z1;
  268.     {
  269.     extern long int xcenter, ycenter;
  270.     extern double xconversion, yconversion;
  271.     extern double SINX, COSX;
  272.     extern long minx, miny, maxx, maxy;
  273.     extern long int lastx, lasty;
  274.     extern int points;
  275.  
  276.     long int xa, ya;
  277.  
  278.     xa = xcenter + (x1 * SINX - y1) * xconversion;
  279.     ya = ycenter - (x1 * COSX - z1) * yconversion;
  280.  
  281.     if (lastx == xa && lasty == ya) return();
  282.  
  283.     lastx = xa;
  284.     lasty = ya;
  285.  
  286.     if (!(xa > minx && xa < maxx && ya > miny && ya < maxy) ) return();
  287.  
  288.     if (parameters->hidden)
  289.         {
  290.         AreaDraw(Window->RPort, xa, ya);
  291.         points++;
  292.         }
  293.     else Draw(Window->RPort, xa, ya);
  294.     }
  295.  
  296. DrawVertices(Window, parameters)
  297. struct Window *Window;
  298. struct Graph_Parameters *parameters;
  299.     {
  300.     extern int points;
  301.  
  302.     if (parameters->hidden) AreaEnd(Window->RPort);
  303.     }
  304.